/**
 * 性能测试示例 - 展示优化前后的性能差异
 */
public class PerformanceTestExample {

    // 原始方法（性能较差）
    public void originalMethod(List<CollegeEnrollmentPlanDO> yearPlans, Set<String> foundCombinationsWithYear) {
        List<CollegeEnrollmentPlanDO> newPlans = new ArrayList<>();
        int duplicateCount = 0;

        for (CollegeEnrollmentPlanDO plan : yearPlans) {
            // 每次都进行字符串拼接，性能开销大
            String uniqueKey = plan.getYear() + ":" + plan.getSchoolName() + ":" +
                             plan.getCollegeMajorName() + ":" + plan.getBatchName() + ":" +
                             plan.getType() + ":" + plan.getProvinceName();

            // 每次都要调用contains方法
            if (foundCombinationsWithYear.contains(uniqueKey)) {
                duplicateCount++;
            } else {
                foundCombinationsWithYear.add(uniqueKey);
                newPlans.add(plan);
            }
        }
    }

    // 优化后的方法（性能更好）
    public void optimizedMethod(List<CollegeEnrollmentPlanDO> yearPlans, Set<String> foundCombinationsWithYear) {
        List<CollegeEnrollmentPlanDO> newPlans = new ArrayList<>();
        int duplicateCount = 0;

        // 高效优化：使用批量处理和优化的去重算法
        Map<String, CollegeEnrollmentPlanDO> uniquePlansMap = new LinkedHashMap<>();

        if (yearPlans.size() > 10000) {
            // 大数据量时使用优化策略
            System.out.println("数据量较大(" + yearPlans.size() + ")，使用优化处理策略");

            // 使用分批处理，每批处理5000条记录
            int batchSize = 5000;
            for (int i = 0; i < yearPlans.size(); i += batchSize) {
                int endIndex = Math.min(i + batchSize, yearPlans.size());
                List<CollegeEnrollmentPlanDO> batch = yearPlans.subList(i, endIndex);

                // 对每批数据进行去重处理
                for (CollegeEnrollmentPlanDO plan : batch) {
                    String uniqueKey = buildUniqueKey(plan);
                    uniquePlansMap.putIfAbsent(uniqueKey, plan);
                }

                // 每处理1万条记录输出一次进度
                if ((i + batchSize) % 10000 == 0 || endIndex == yearPlans.size()) {
                    System.out.println("数据处理进度: " + endIndex + "/" + yearPlans.size());
                }
            }
        } else {
            // 小数据量时使用传统方式
            for (CollegeEnrollmentPlanDO plan : yearPlans) {
                String uniqueKey = buildUniqueKey(plan);
                uniquePlansMap.putIfAbsent(uniqueKey, plan);
            }
        }

        // 过滤已存在于全局集合中的记录
        Iterator<Map.Entry<String, CollegeEnrollmentPlanDO>> iterator = uniquePlansMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, CollegeEnrollmentPlanDO> entry = iterator.next();
            if (foundCombinationsWithYear.contains(entry.getKey())) {
                duplicateCount++;
                iterator.remove();
            }
        }

        // 批量添加到全局去重集合和结果列表
        foundCombinationsWithYear.addAll(uniquePlansMap.keySet());
        newPlans.addAll(uniquePlansMap.values());
    }

    private String buildUniqueKey(CollegeEnrollmentPlanDO plan) {
        // 使用StringBuilder构建唯一标识，性能更好
        StringBuilder keyBuilder = new StringBuilder(128); // 预分配容量
        return keyBuilder
                .append(plan.getYear()).append(':')
                .append(plan.getSchoolName() != null ? plan.getSchoolName() : "").append(':')
                .append(plan.getCollegeMajorName() != null ? plan.getCollegeMajorName() : "").append(':')
                .append(plan.getBatchName() != null ? plan.getBatchName() : "").append(':')
                .append(plan.getType() != null ? plan.getType() : "").append(':')
                .append(plan.getProvinceName() != null ? plan.getProvinceName() : "")
                .toString();
    }
}
